package com.xuecheng.content.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.xuecheng.api.content.model.dto.CourseBaseDTO;
import com.xuecheng.api.content.model.qo.QueryCourseModel;
import com.xuecheng.api.content.model.vo.CourseBaseVO;
import com.xuecheng.common.domain.code.CommonErrorCode;
import com.xuecheng.common.domain.page.PageRequestParams;
import com.xuecheng.common.domain.page.PageVO;
import com.xuecheng.common.enums.common.CommonEnum;
import com.xuecheng.common.enums.content.CourseAuditEnum;
import com.xuecheng.common.enums.content.CourseChargeEnum;
import com.xuecheng.common.exception.ExceptionCast;
import com.xuecheng.common.util.CommonUtil;
import com.xuecheng.common.util.StringUtil;
import com.xuecheng.content.common.constant.ContentErrorCode;
import com.xuecheng.content.config.LocalDateTimeConfig;
import com.xuecheng.content.controller.CourseAuditController;
import com.xuecheng.content.convert.CourseBaseConvert;
import com.xuecheng.content.entity.CourseBase;
import com.xuecheng.content.entity.CourseMarket;
import com.xuecheng.content.mapper.CourseBaseMapper;
import com.xuecheng.content.service.CourseBaseService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.xuecheng.content.service.CourseMarketService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;

/**
 * <p>
 * 课程基本信息 服务实现类
 * </p>
 *
 * @author itcast
 */
@Slf4j
@Service
public class CourseBaseServiceImpl extends ServiceImpl<CourseBaseMapper, CourseBase> implements CourseBaseService {

    @Autowired
    private CourseMarketService courseMarketService;

    /**
     * 查询课程基本信息
     *
     * @return java.util.List<com.xuecheng.content.entity.CourseBaseDTO>
     * @author Lily
     * @date 2021/12/8 19:20
     * @paramType []
     * @description
     */
    @Override
    public List<CourseBase> queryAll() {
        List<CourseBase> result = list();
        return result;
    }

    /**
     * 查询课程基地名单
     *
     * @param params 分页参数
     * @param model  查询参数
     * @return com.xuecheng.common.domain.page.PageVO
     * @author Lily
     * @date 2021/12/8 20:54
     * @paramType [com.xuecheng.common.domain.page.PageRequestParams, com.xuecheng.api.content.model.qo.QueryCourseModel]
     * @description 1.判断数据的合法性
     * 2.构建分页对象
     * 3.构建查询条件
     * 4.查询数据内容获得结果
     * 5.构建查询结果
     * 6.返回查询结果
     */
    @Override
    public PageVO queryCourseBaseList(PageRequestParams params, QueryCourseModel model, Long companyId) {
//        * 1.判断数据的合法性
        if (params.getPageNo() < 1) {
            params.setPageNo(PageRequestParams.DEFAULT_PAGE_NUM);
        }
        if (params.getPageSize() < 1) {
            params.setPageSize(PageRequestParams.DEFAULT_PAGE_SIZE);
        }
//        * 2.构建分页对象
        Page<CourseBase> page = new Page<>(params.getPageNo(), params.getPageSize());
//        * 3.构建查询条件
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
//        String courseName = model.getCourseName();
//        if (courseName != null || courseName.trim() != ""){
//            queryWrapper.like(CourseBase::getName, courseName);
//        }
        // 添加对公司的条件查询
        // TODO 运营平台查询时，判断常量值，如果有该值，则不用匹配该数据
        if (!ObjectUtils.nullSafeEquals(CourseAuditController.OPERATION_FLAG, companyId)) {
            queryWrapper.eq(CourseBase::getCompanyId, companyId);
        }

        queryWrapper.like(StringUtil.isNotBlank(model.getCourseName()), CourseBase::getName, model.getCourseName());
        queryWrapper.like(StringUtil.isNotBlank(model.getAuditStatus()), CourseBase::getAuditStatus, model.getAuditStatus());
//        * 4.查询数据内容获得结果
        Page<CourseBase> basePage = this.page(page, queryWrapper);
        List<CourseBase> records = basePage.getRecords();
        long total = basePage.getTotal();
        // 创建一个不占空间的List对象，用于判断是否查询结果为空
        List<CourseBaseDTO> dtos = Collections.emptyList();
        if (!CollectionUtils.isEmpty(records)) {
            // 不为空，则封装进 dto
            dtos = CourseBaseConvert.INSTANCE.entities2dtos(records);
        }
//        * 5.构建查询结果
        PageVO<CourseBaseDTO> pageVO = new PageVO<>(dtos, total, params.getPageNo(), params.getPageSize());
//        * 6.返回查询结果
        return pageVO;
    }


    /**
     * 创建基础课程内容
     *
     * @param courseBaseDTO CourseBaseDTO 将前端传递的vo数据封装成dto数据
     * @return com.xuecheng.api.content.model.dto.CourseBaseDTO
     * @author Lily
     * @date 2021/12/11 16:25
     * @paramType [com.xuecheng.api.content.model.vo.CourseBaseVO]
     * @description 需要将前端传递的 vo数据，转成 dto数据，防止黑客知道数据库的字段名
     * 业务分析：
     * 1 是否开启事务
     * 1.1 增删改需要开启，查询不需要，且如果有方法的引用，则被调用的方法不需要开启事务
     * 2 判断关键数据（必填数据）
     * 2.1 由前端传入，来源于前端、数据库字段约束、开发接口文档
     * 3 判断业务数据（数据回显，选项）
     * 3.1 添加没有业务数据判断，一般来源于数据来源于后端。
     * 4 判断数据是否需要赋值（是否有默认值，数据库、前端传递）
     * 4.1 status：是否逻辑删除，数据库有默认值
     * 4.2 auditStatus：审核状态，新添加的课程为未提交--是一个状态码，有常量值调用
     * 5 将 dto 转成 po
     * 5.1 mp的 api只能对 po进行操作
     * 6 保存数据并返回结果，判断是否成功
     * 7 将 po转成 dto返回给前端
     */
    @Override
    @Transactional
    public CourseBaseDTO createCourseBase(CourseBaseDTO courseBaseDTO) {
        //1 是否开启事务
        //    1.1 增删改需要开启，查询不需要，且如果有方法的引用，则被调用的方法不需要开启事务


        //2 判断关键数据（必填数据）
        //    2.1 由前端传入，来源于前端、数据库字段约束、开发接口文档
        verifyCourseMsg(courseBaseDTO);


        //3 判断业务数据（数据回显，选项）
        //    3.1 添加没有业务数据判断，一般来源于数据来源于后端。


        //4 判断数据是否需要赋值（是否有默认值，数据库、前端传递）
        //    4.1 status：是否逻辑删除，数据库有默认值
        //    4.2 auditStatus：审核状态，新添加的课程为未提交--是一个状态码，有常量值调用
        courseBaseDTO.setAuditStatus(CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode());


        //5 将 dto 转成 po
        //    5.1 mp的 api只能对 po进行操作
        CourseBase courseBase = CourseBaseConvert.INSTANCE.dto2entity(courseBaseDTO);


        //6 保存数据并返回结果，判断是否成功
        boolean insetResult = this.save(courseBase);
        if (!insetResult) {
            ExceptionCast.cast(ContentErrorCode.E_120001);
        }
        //6.1 设置课程营销信息，包含课程id，是否收费，如果收费价格多少
        CourseMarket courseMarket = new CourseMarket();
        //6.1 设置课程的id、是否收费
        String charge = courseBaseDTO.getCharge();
        courseMarket.setCourseId(courseBase.getId());
        courseMarket.setCharge(charge);
        //6.2 判断是否为收费课程，如果是则设置价格
        if (CourseChargeEnum.CHARGE_YES.getCode().equals(charge)) {
            //6.3 判断价格是否为空
            BigDecimal price = courseBaseDTO.getPrice();
            //TODO 6.4 如果价格为空，这里应该校验数据的有效性，而不是判断是否为空，测试数据为负数也可以保存
            if (ObjectUtils.isEmpty(price)) {
                ExceptionCast.cast(ContentErrorCode.E_120104);
            }
            //6.5 不为空
            courseMarket.setPrice(price.floatValue());
        }
        //6.6 将营销数据保存
        boolean courseMarketResult = courseMarketService.save(courseMarket);
        if (!courseMarketResult) {
            ExceptionCast.cast(ContentErrorCode.E_120107);
        }


        //7 将 po转成 dto返回给前端，但是 courseBase表中没有营销数据，且有不少自动生成的数据，因此要通过 id查询数据库
        //7.1 因为 mp自动回填了 id，因此可以直接通过 id查询到
        CourseBaseDTO dtoResult = getLastCourseDTO(courseBaseDTO, courseBase);

        return dtoResult;
    }

    /**
     * 获取最新的dto
     *
     * @param courseBaseDTO 课程基础dto
     * @param courseBase    课程基础
     * @return {@link CourseBaseDTO}
     */
    private CourseBaseDTO getLastCourseDTO(CourseBaseDTO courseBaseDTO, CourseBase courseBase) {
        CourseBase po = this.getById(courseBase.getId());
        CourseBaseDTO dtoResult = CourseBaseConvert.INSTANCE.entity2dto(po);
        dtoResult.setCharge(courseBaseDTO.getCharge());
        //TODO 这里获取的pirce是前端传过来的，如果是null则不会赋值，如果是非法数据，会不会有问题
        dtoResult.setPrice(courseBaseDTO.getPrice());
        return dtoResult;
    }

    /**
     * 判断关键数据，哪些是必填
     *
     * @param courseBaseDTO 课程基础dto
     */
    private void verifyCourseMsg(CourseBaseDTO courseBaseDTO) {
        /* 判断公司id是否为空 */
        if (ObjectUtils.isEmpty(courseBaseDTO.getCompanyId())) {
            ExceptionCast.cast(ContentErrorCode.E_120018);
        }
        /* 判断课程名称不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getName())) {
            ExceptionCast.cast(ContentErrorCode.E_120004);
        }
        /* 课程大分类不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getMt())) {
            ExceptionCast.cast(ContentErrorCode.E_120002);
        }
        /* 课程小分类不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getSt())) {
            ExceptionCast.cast(ContentErrorCode.E_120003);
        }
        /* 课程等级不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getGrade())) {
            ExceptionCast.cast(ContentErrorCode.E_120007);
        }
        /* 课程教学模式不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getTeachmode())) {
            ExceptionCast.cast(ContentErrorCode.E_120006);
        }
        /* 使用人群不能为空 */
        if (StringUtil.isBlank(courseBaseDTO.getUsers())) {
            ExceptionCast.cast(ContentErrorCode.E_120019);
        }
        /* 课程收费不能为空，这个字段要在 dto中定义，数据表中没有该字段*/
        if (StringUtil.isBlank(courseBaseDTO.getCharge())) {
            ExceptionCast.cast(ContentErrorCode.E_120104);
        }
    }


    /**
     * 修改基础课程内容
     *
     * @param courseBaseDTO CourseBaseDTO 将前端传递的vo数据封装成dto数据
     * @return com.xuecheng.api.content.model.dto.CourseBaseDTO
     * @author Lily
     * @date 2021/12/11 16:25
     * @paramType [com.xuecheng.api.content.model.vo.CourseBaseVO]
     * @description 需要将前端传递的 vo 数据，转成 dto 数据，防止黑客知道数据库的字段名
     * <p>
     * 业务分析：
     * 1 判断关键数据
     * 修改有 courseId
     * 2 判断业务数据
     * 课程基本信息
     * 判断课程计划是否存在
     * 判断是否是同一家机构
     * 判断课程是否删除
     * 判断课程的审核状态，未提交、审核未通过才能修改
     * 课程营销信息
     * 3 修改数据内容
     * 课程基本信息表
     * 不可更改：courseBaseId、companyid、auditstatus、status
     * 课程营销表
     * 可更改：charge price，修改数据时要判断修改后结果
     * 4 返回前端最新的数据库的数据并封装为dto返回
     */
    @Transactional
    @Override
    public CourseBaseDTO modifyCourseBase(CourseBaseDTO courseBaseDTO) {

        //1 判断关键数据
        //    修改有 courseId
        if (ObjectUtils.isEmpty(courseBaseDTO.getCourseBaseId())) {
            ExceptionCast.cast(ContentErrorCode.E_120009);
        }
        verifyCourseMsg(courseBaseDTO);


        //2 判断业务数据
        // 获取课程基本内容id
        Long courseBaseId = courseBaseDTO.getCourseBaseId();

        //    课程基本信息
        //        判断课程计划是否存在
        LambdaQueryWrapper<CourseBase> baseQueryWrapper = new LambdaQueryWrapper<>();
        baseQueryWrapper.eq(CourseBase::getId, courseBaseId);

        //        判断是否是同一家机构
        baseQueryWrapper.eq(CourseBase::getCompanyId, courseBaseDTO.getCompanyId());

        // 如果课程不存在抛出课程不存在异常
        CourseBase courseBase = this.getOne(baseQueryWrapper);
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        //        判断课程是否删除
        Integer status = courseBase.getStatus();
        if (CommonEnum.DELETE_FLAG.getCodeInt().equals(status)) {
            ExceptionCast.cast(ContentErrorCode.E_120020);
        }

        //        判断课程的审核状态，未提交、审核未通过才能修改
        verifyAuditStatus(courseBase);

        //    课程营销信息
        //查询课程营销信息是否能存在
        LambdaQueryWrapper<CourseMarket> marketQueryWrapper = new LambdaQueryWrapper<>();
        marketQueryWrapper.eq(CourseMarket::getCourseId, courseBaseId);
        CourseMarket market = courseMarketService.getOne(marketQueryWrapper);
        if (ObjectUtils.isEmpty(market)) {
            ExceptionCast.cast(ContentErrorCode.E_120101);
        }

        //3 修改数据内容
        //将 dto 转成 po，mp只能操作 po
        CourseBase po = CourseBaseConvert.INSTANCE.dto2entity(courseBaseDTO);
        //    课程基本信息表
        //        不可更改：courseBaseId、companyid、auditstatus、status
        //将不允许改的内容设为 null
        //TODO 这里如果是为 null 就不能根据 id修改了，且这里到底需要重置 id吗？
        //po.setId(null);
        po.setCompanyId(null);
        po.setAuditStatus(null);
        po.setStatus(null);
        //更新 courseBase 表数据，若果未成功报错
        boolean updateResult = this.updateById(po);
        if (!updateResult) {
            ExceptionCast.cast(ContentErrorCode.E_120021);
        }

        //    课程营销表
        //        可更改：charge price，修改数据时要判断修改后结果
        LambdaUpdateWrapper<CourseMarket> marketUpdateWrapper = new LambdaUpdateWrapper<>();
        String charge = courseBaseDTO.getCharge();
        marketUpdateWrapper.set(CourseMarket::getCharge, charge);
        //判断当前课程是否收费
        if (CourseChargeEnum.CHARGE_YES.getCode().equals(charge)) {
            //获取修改后价格
            BigDecimal price = courseBaseDTO.getPrice();
            //收费课程价格不能为空
            if (ObjectUtils.isEmpty(price)) {
                ExceptionCast.cast(ContentErrorCode.E_120104);
            }
            //TODO 不为空则保存，但这里如果为负数，会保存吗？
            marketUpdateWrapper.set(CourseMarket::getPrice, price);
        }
        //添加一个 where条件，限定更改哪条数据
        marketUpdateWrapper.eq(CourseMarket::getCourseId, courseBaseId);
        //判断是否修改成功
        boolean marketResult = courseMarketService.update(marketUpdateWrapper);
        if (!marketResult) {
            ExceptionCast.cast(ContentErrorCode.E_120107);
        }

        //4 返回前端最新的数据库的数据并封装为dto返回
        CourseBaseDTO dtoResult = getLastCourseDTO(courseBaseDTO, courseBase);
        return dtoResult;
    }


    /**
     * 验证审核状态
     *
     * @param courseBase 课程基础
     */
    private void verifyAuditStatus(CourseBase courseBase) {
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120014);
        }
    }


    /**
     * 通过课程id和公司id查询数据，并查询是否
     *
     * @param courseId  课程id
     * @param companyId 公司id
     * @return com.xuecheng.content.entity.CourseBase
     * @author Lily
     * @date 2021/12/12 22:28
     * @paramType [java.lang.Long, java.lang.Long]
     * @description
     */
    @Override
    public CourseBase getCourseBaseById(Long courseId, Long companyId) {
        // 2.判断业务数据
        // 2-1.课程基础信息：是否存在、同一家公司、是否删除、审核状态（未提交和审核未通过）
        // 获取课程的审核审核状态
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();

        // 课程id
        queryWrapper.eq(CourseBase::getId, courseId);

        // 公司id
        queryWrapper.eq(CourseBase::getCompanyId, companyId);

        // 是否删除
        queryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCodeInt());
        CourseBase courseBase = this.getOne(queryWrapper);

        // 查不到则课程信息不存在
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        // 判断审核状态（未提交和审核未通过）
        verifyAuditStatus(courseBase);

        return courseBase;
    }

    /**
     * 根据id删除课程基础
     *
     * @param courseBaseId 课程基础id
     * @author Lily
     * @date 2021/12/11 23:02
     * @paramType [java.lang.Long]
     * @description 业务分析：
     * 1 判断关键数据的合法性
     * 1.1 courseBaseId    companyId
     * 2 根据id获取课程的基本信息
     * 3 判断课程的审核状态
     * 4 修改课程信息状态值
     */
    @Override
    public void removeCourseBase(Long courseBaseId, Long companyId) {

        //1 判断关键数据的合法性
        //    1.1 courseBaseId    companyId
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)
        ) {
            // 异常是传入的参数与接口不符
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        //2.1 根据id获取课程的基本信息，判断课程是否存在
        CourseBase courseBase = this.getById(courseBaseId);
        if (ObjectUtils.isEmpty(courseBase)) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }
        //TODO 2.2 判断是否为同一家机构，这里老师代码时错误的
//        if (ObjectUtils.nullSafeEquals(courseBase.getCompanyId(), companyId)){
//            ExceptionCast.cast(CommonErrorCode.E_100108);
//        }
        if (!courseBase.getCompanyId().equals(companyId)) {
            ExceptionCast.cast(CommonErrorCode.E_100108);
        }

        //3 判断课程的审核状态
        verifyAuditStatus(courseBase);

        //4 修改课程信息状态值
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        //将状态设为删除
        updateWrapper.set(CourseBase::getStatus, CommonEnum.DELETE_FLAG.getCodeInt());
        //更新修改日期
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        //添加判断条件
        updateWrapper.eq(CourseBase::getId, courseBaseId);
        boolean result = this.update(updateWrapper);
        //判断是否删除成功
        if (!result) {
            ExceptionCast.cast(ContentErrorCode.E_120017);
        }
    }


    /**
     * 提交课程基础
     *
     * @param courseBaseId 课程基础id
     * @param companyId    公司标识
     * @author Lily
     * @date 2021/12/13 20:14
     * @paramType [java.lang.Long, java.lang.Long]
     * @description 业务分析：
     * 1.判断关键数据
     * 2.判断业务数据
     * 课程基础信息
     * 判断是否存在
     * 判断是否是同一家教学机构
     * 判断是否删除
     * 判断审核状态
     * 3.修改课程审核状态
     * 已提交
     */
    @Transactional
    @Override
    public void commitCourseBase(Long courseBaseId, Long companyId) {

        //1.判断关键数据
        // 课程基础id和公司id不能为空
        if (ObjectUtils.isEmpty(courseBaseId) ||
                ObjectUtils.isEmpty(companyId)
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        //2.判断业务数据
        //    课程基础信息
        //        判断是否存在
        //        判断是否是同一家教学机构
        //        判断是否删除
        //        判断审核状态
        getCourseByLogic(companyId, courseBaseId);

        //3.修改课程审核状态
        //     已提交
        //  createDate  changeDate 使用MP自动填充来完成
        //  UpdateWrapper 会将MP的自动填充功能失效
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getAuditStatus, CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        updateWrapper.eq(CourseBase::getId, courseBaseId);

        boolean updateResult = this.update(updateWrapper);

        if (!updateResult) {
            ExceptionCast.cast(ContentErrorCode.E_120017);
        }
    }

    private void getCourseByLogic(Long companyId, Long courseBaseId) {
        // TODO 这个方法里包含了课程基础的判断，是否存在和公司id
        CourseBase courseBase = getCourseBaseById(courseBaseId, companyId);
        // 判断审核状态
        String auditStatus = courseBase.getAuditStatus();
        if (CourseAuditEnum.AUDIT_PASTED_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120018);
        }
    }


    /**
     * 课程审核
     *
     * @param courseBaseDTO 课程基础dto
     * @author Lily
     * @date 2021/12/13 21:58
     * @paramType [com.xuecheng.api.content.model.dto.CourseBaseDTO]
     * @description 业务分析：
     * 1.判断关键数据
     * auditMind  auditStatus  courseid
     * 2.判断业务数据
     * 课程基础信息
     * 判断是否存在
     * 判断是否删除
     * 判断审核状态
     * 必须为：已提交
     * 审核状态
     * 运营平台只能给课程审核状态赋值：审核通过、审核未通过
     * 3.修改课程审核信息
     * auditMind  auditStatus  auditNum（每次+1）
     */
    @Override
    public void approve(CourseBaseDTO courseBaseDTO) {

        // 1.判断关键数据
        //     auditMind  auditStatus  courseid
        if (ObjectUtils.isEmpty(courseBaseDTO.getAuditMind()) ||
                ObjectUtils.isEmpty(courseBaseDTO.getAuditStatus()) ||
                ObjectUtils.isEmpty(courseBaseDTO.getCourseBaseId())
        ) {
            ExceptionCast.cast(CommonErrorCode.E_100101);
        }

        // 2.判断业务数据
        //     课程基础信息
        //         判断是否存在
        //         判断是否删除
        //         判断审核状态
        //             必须为：已提交
        LambdaQueryWrapper<CourseBase> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CourseBase::getId, courseBaseDTO.getCourseBaseId());
        queryWrapper.eq(CourseBase::getStatus, CommonEnum.USING_FLAG.getCodeInt());
        queryWrapper.eq(CourseBase::getAuditStatus, CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode());

        // 判断是否有数据
        int count = this.count(queryWrapper);
        if (count < 1) {
            ExceptionCast.cast(ContentErrorCode.E_120013);
        }

        //     审核状态
        //         运营平台只能给课程审核状态赋值：审核通过、审核未通过，判断是否操作不可以操作的课程
        String auditStatus = courseBaseDTO.getAuditStatus();
        if (CourseAuditEnum.AUDIT_PUBLISHED_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_UNPAST_STATUS.getCode().equals(auditStatus) ||
                CourseAuditEnum.AUDIT_COMMIT_STATUS.getCode().equals(auditStatus)
        ) {
            ExceptionCast.cast(ContentErrorCode.E_120016);
        }

        // 3.修改课程审核信息
        //     auditMind  auditStatus  auditNum（每次+1）
        LambdaUpdateWrapper<CourseBase> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(CourseBase::getAuditMind, courseBaseDTO.getAuditMind());
        updateWrapper.set(CourseBase::getAuditStatus, courseBaseDTO.getAuditStatus());

        // 每次加一通过redis实现
        CourseBase courseBase = this.getById(courseBaseDTO.getCourseBaseId());
        updateWrapper.set(CourseBase::getAuditNums, courseBase.getAuditNums() + 1);

        // update不能自动更新时间
        updateWrapper.set(CourseBase::getChangeDate, LocalDateTime.now());
        updateWrapper.eq(CourseBase::getId, courseBaseDTO.getCourseBaseId());

        boolean updateResult = this.update(updateWrapper);
        if (!updateResult){
            ExceptionCast.cast(ContentErrorCode.E_120017);
        }
    }
}
